#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define kMaxSize 201
typedef int Position; /* 整型下标，表示元素的位置 */
#define NIL -1
typedef struct StringNode *String;
struct StringNode {
    char data[kMaxSize]; /* 存储字符的数组 */
    int length; /* 字符串长度 */
};

String InitStr(); /* 代码4-1给出*/
void ReadString(String s); /* 代码4-17略改 */
void SubString(String s, int pos, int len, String sub_s); /* 代码4-3略改 */
void StrRemove(String s, Position pos, int len); /* 代码4-2给出 */
void StrInsert(String s, Position pos, String t); /* 代码4-1给出*/
void StrConcat(String s, String t); /* 代码4-4给出*/
Position PatternMatch(String s, Position start,
                      String t); /* 代码4-17略改 */

int main(void) {
    String s, clipboard, s1, s2;
    int n, i;
    Position p1, p2;

    s = InitStr(); /* 原始字符串 */
    clipboard = InitStr(); /* 剪贴板 */
    s1 = InitStr(); /* 插入位置前的字符串 */
    s2 = InitStr(); /* 插入位置后的字符串 */

    ReadString(s); /* 读入原始字符串 */
    scanf("%d\n", &n); /* 读入操作次数 */
    for (i = 0; i < n; i++) { /* 逐次执行操作 */
        scanf("%d %d ", &p1, &p2); /* 读入剪切位置 */
        SubString(s, p1, p2 - p1 + 1, clipboard); /* 将子串存入剪贴板 */
        StrRemove(s, p1, p2 - p1 + 1); /* 删除该子串 */
        ReadString(s1); /* 读入插入位置前的字符串 */
        ReadString(s2); /* 读入插入位置后的字符串 */
        p1 = PatternMatch(s, 0, s1); /* 从s的初始位置开始，匹配s1 */
        while (p1 != NIL) { /* 如果s1匹配成功 */
            p2 = PatternMatch(s, p1 + s1->length, s2); /* 跳过s1开始匹配s2 */
            if (p1 + s1->length == p2) { /* 如果匹配成功的s1和s2相连 */
                break; /* 则找到了插入的位置，跳出循环 */
            } else { /* 当前找到的s1不满足要求 */
                p1 = PatternMatch(s, p1 + 1,
                                  s1); /* 从下一个位置开始再次尝试匹配s1 */
            }
        }
        if (p1 != NIL) { /* 找到了插入的位置 */
            StrInsert(s, p2 + 1, clipboard); /* 将剪贴板内容插入 */
        } else { /* 插入位置没找到 */
            StrConcat(s, clipboard); /* 将剪贴板内容贴在s最后 */
        }
        clipboard->length = 0; /* 清空剪贴板 */
    }
    printf("%s\n", s->data); /* 输出最后结果 */

    return 0;
}

String InitStr() {
    /* 初始化一个空的字符串 */
    String s;

    s = (String)malloc(sizeof(struct StringNode));
    s->length = 0;

    return s;
}

void ReadString(String s) {
    scanf("%s ", s->data); /* 输入字符串没有空格 */
    s->length = strlen(s->data); /* 需要string.h */
}

void SubString(String s, int pos, int len, String sub_s) {
    /* pos从1开始 */
    /* sub_s作为参数传入 */
    int n;
    Position i;

    n = s->length;
    i = 0;
    while (((pos - 1 + i) <= n) && (i < len)) {
        /* 若s从pos-1开始不到len个字符，就截取到s的末尾为止 */
        /* 将s串从pos-1之后的len个字符复制到sub_s */
        sub_s->data[i] = s->data[pos - 1 + i];
        sub_s->length++;
        i++;
    }
    sub_s->data[i] = '\0';
}

void StrRemove(String s, Position pos, int len) {
    /* pos从1开始 */
    int n;
    Position i;

    n = s->length;
    if ((pos + len - 1) <= n) {
        for (i = pos + len - 1; i <= n; i++) { /* i=n处理结束符 */
            s->data[i - len] = s->data[i];
        }
        s->length = n - len;
    } else {
        s->data[pos - 1] =
            '\0'; /* 从数组下标pos-1开始的所有字符都删掉 */
        s->length = pos - 1;
    }
}

void StrInsert(String s, Position pos, String t) {
    /* pos从1开始*/
    int n, m;
    Position i;

    n = s->length;
    m = t->length;
    if ((n + m) < kMaxSize) { /* 如果插入后不超长 */
        for (i = n; i >= (pos - 1); i--) { /* i=n时将结束符后移 */
            s->data[i + m] =
                s->data[i]; /*将下标pos-1开始的子串后移，给t留出空位*/
        }
        for (i = 0; i < m; i++) {
            s->data[pos - 1 + i] = t->data[i]; /* 将t插入s */
        }
        s->length = n + m;
    } else {
        printf("错误：插入将导致字符串长度超限。\n");
    }
}

void StrConcat(String s, String t) {
    int n, m;
    Position i;

    n = s->length;
    m = t->length;
    if ((n + m) <= kMaxSize) { /* 若串接后不超长 */
        for (i = 0; i <= m; i++) { /* i=m处理结束符 */
            s->data[n + i] = t->data[i];
        }
        s->length = n + m;
    } else {
        printf("错误：连接将导致字符串长度超限。\n");
    }
}

Position PatternMatch(String s, Position start, String t) {
    /* 任何匹配算法都可以放在这个函数里 */
    /* 返回t在s从start开始向后的子串中首次出现的位置 */
    /* 位置是数组的下标 */
    char *p;

    p = strstr(s->data + start, t->data); /* 需要string.h */
    if (p == NULL)
        return NIL;
    else {
        return (p - s->data);
    }
}